The previous `__del__`-only autosave path silently lost cache updates when
the engine survived until interpreter exit (typical for inference servers).
Python tears down `sys.meta_path` early in shutdown; the torchbind
attribute access in `self._handle.path` and the lazy `filelock` import
inside `save()` then raise `ImportError: sys.meta_path is None`, which
escaped `__del__` and surfaced as a noisy `Exception ignored in __del__`
once per surviving handle.

`atexit` callbacks run *before* module teardown, so the torchbind path
and lazy imports still resolve there. Register an `atexit` hook from
`__init__` whenever `autosave_on_del=True`. The hook closes over a
`weakref.ref(self)` so it doesn't pin the handle alive: a handle that
dies mid-program still goes through `__del__`, and the atexit hook later
sees a dead weakref and no-ops.

Other design points worth calling out:

* `_autosave_at_exit` is a module-level helper, not a bound method. A
  bound method captures `self` via `__self__`, which would defeat the
  weakref. The free function lets the closure carry only the weakref.

* Both `__del__` and the atexit hook flip `autosave_on_del` off before
  saving so whichever path runs first wins and the other no-ops -- no
  double-save, no double-leak risk.

* `__del__` unregisters its atexit token. Without this, a long-running
  process that churns engine-implicit handles (model swaps, A/B
  rollouts) accumulates dead atexit entries -- small per entry but
  unbounded.

* The `try` in `__del__` still wraps the whole body so any residual
  attribute-access failure during late-shutdown corner cases is swallowed
  rather than leaking to `sys.unraisablehook`.

Tests added in `TestRuntimeCacheAutosave`:
- `test_del_swallows_shutdown_import_error_on_path`: monkey-patches
  `_handle.path` to raise the shutdown `ImportError`; asserts via
  `sys.unraisablehook` that nothing leaks.
- `test_atexit_hook_saves_via_weakref`: exercises the helper directly,
  verifies it saves and flips `autosave_on_del`.
- `test_atexit_hook_no_op_on_dead_weakref`: dead weakref => no-op, no
  exception.
- `test_atexit_token_unregistered_after_del`: `atexit.unregister` is
  spied to confirm `__del__` cleaned up.

Refs pytorch#4359

The atexit + weakref design from the previous commit added an
``_atexit_token`` slot (``partial(_autosave_at_exit, weakref.ref(self))``)
to ``RuntimeCache``. ``weakref.ref`` is unpicklable, so any caller that
pickled a ``RuntimeCache`` directly hit
``TypeError: cannot pickle 'weakref.ReferenceType'``.

Two defenses:

* ``__getstate__`` / ``__setstate__`` strip the token from the pickle
  stream and re-register a fresh atexit hook on unpickle when
  ``autosave_on_del`` was on. Atexit registration is a per-process
  artifact; the loading process gets its own hook bound to the loading-
  side instance.

* ``__del__`` reads ``_atexit_token`` via ``getattr(..., None)``.
  ``__init__`` sets the slot first, but ``copy.deepcopy`` can crash
  mid-state-copy on an unrelated field (e.g. the python-runtime
  ``_RuntimeCacheHandle._lock``, which is ``threading.Lock``) and leave
  the new instance with only some attributes set. The defensive read
  keeps ``__del__`` quiet rather than raising ``AttributeError`` to
  ``sys.unraisablehook``.

Test ``test_pickle_round_trip_strips_atexit_token`` exercises the
standalone-pickle path with a ``SimpleNamespace`` stub for ``_handle``
so the test isolates the ``__getstate__``/``__setstate__`` logic from
the orthogonal limitation that ``_RuntimeCacheHandle`` (python rt) is
itself unpicklable today.

The wrapper-side fix that prevents engine-implicit handles from being
pickled via ``torch.save(module)`` at all -- plus the matching
``_RuntimeCacheHandle`` picklability fix on python-rt -- is intentionally
a separate change; this commit only addresses pickle safety of the
``_atexit_token`` slot introduced in the prior commit.

Refs pytorch#4359

…helper

``__init__`` and ``__setstate__`` both registered the same
``atexit.register(partial(_autosave_at_exit, weakref.ref(self)))``
call. Hoist into ``_register_atexit_autosave`` and reuse from both
sites. The idempotency check (``_atexit_token is None``) moves into the
helper, so a second call is a no-op regardless of caller.

Behavior is unchanged. Addresses review comment on
py/torch_tensorrt/runtime/_runtime_cache.py:227.